home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / modula2 / hk_lib / def_mod / mathbase.def < prev    next >
Encoding:
Modula Definition  |  1994-09-22  |  8.8 KB  |  167 lines
  1. DEFINITION MODULE  MathBase;
  2.  
  3. (*****************************************************************************)
  4. (* In diesem Modul gibt es Grundfunktionen fuer die Behandlung von REAL- bzw.*)
  5. (* LONGREAL-Zahlen, die bei der Programmierung mathematischer Funktionen     *)
  6. (* verwendet werden koennen, da hierbei oft auf Teile der REAL-Repraesenta-  *)
  7. (* tion zugegriffen wird.                                                    *)
  8. (* Ausserdem gibt es noch einige Funktionen, die normalerweise in "MathLib0" *)
  9. (* bzw. "LongMathLib0" angesiedelt sind, aber weil sie so grundlegend und    *)
  10. (* keine 'hoeheren' Funktionen sind, habe ich sie hier reingepackt.          *)
  11. (*                                                                           *)
  12. (* Bis auf die Funktion "sarctan" kann das Modul als Ersatz fuer das Origi-  *)
  13. (* nalmodul "MathCom" dienen ( "SplitReal" und "GetFraction" fuer die fehler-*)
  14. (* haften "frexp" und "modf" und "MakeReal" fuer das wesentlich langsamere   *)
  15. (* "ldexp" ).                                                                *)
  16. (*___________________________________________________________________________*)
  17. (*   26-Feb-90 , Holger Kleinschmidt                                         *)
  18. (*****************************************************************************)
  19.  
  20. FROM  SYSTEM  IMPORT  (* PROC *) VAL;
  21.  
  22. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  23.  
  24. CONST
  25.       MAXint      =  32767.0;
  26.       MINint      = -32768.0;
  27.       MAXcard     =  65535.0;
  28.  
  29.       MAXREAL     = MAX( REAL );
  30.       MINREAL     = VAL( REAL, 00800000H ); (* = 2^(-126) * 1.0 *)
  31.  
  32.       MAXlongint  = 2147483647.0D;
  33.       MAXlongcard = 4294967295.0D;
  34.  
  35.       MAXLONGREAL = MAX( LONGREAL );
  36.  
  37.  
  38. (***** ! DIE FOLGENDEN VARIABLEN NUR ALS KONSTANTE VERWENDEN ! *****)
  39.  
  40. VAR
  41.       MINLONGREAL : LONGREAL;   (* wird mit der kleinsten darstellbaren
  42.                                  * LONGREAL-Zahl initialisiert.
  43.                                  *  = 2^(-1022) * 1.0D
  44.                                  *)
  45.       MINlongint  : LONGREAL;   (* wird mit der kleinsten LONGINT-Zahl
  46.                                  * initialisiert.
  47.                                  *)
  48.  
  49. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  50.  
  51.   PROCEDURE SplitReal     ((* EIN/ -- *)     value : REAL;
  52.   (* = MathCom.frexp *)    (* -- /AUS *) VAR exp   : INTEGER ): REAL;
  53.  
  54.   PROCEDURE SplitLongReal ((* EIN/ -- *)     value : LONGREAL;
  55.                            (* -- /AUS *) VAR exp   : INTEGER   ): LONGREAL;
  56.  
  57.  (*-------------------------------------------------------------------------
  58.   | Spalten <value> in die Mantisse 'mant', die als Funktionswert geliefert |
  59.   | wird, und den Exponenten <exp> auf; es gilt also:                       |
  60.   |                                                                         |
  61.   |          value = mant * 2^exp  , mit  1.0 <= |mant| < 2.0               |
  62.   |                                                                         |
  63.   | Ist <value> = 0.0, dann wird <exp> := 0 und mant := 0.0 .               |
  64.    -------------------------------------------------------------------------*)
  65.  
  66.  
  67.   PROCEDURE MakeReal     ((* EIN/ -- *) mant : REAL;
  68.   (* = MathCom.ldexp *)   (* EIN/ -- *) exp  : INTEGER ): REAL;
  69.  
  70.   PROCEDURE MakeLongReal ((* EIN/ -- *) mant : LONGREAL;
  71.                           (* EIN/ -- *) exp  : INTEGER   ): LONGREAL;
  72.  
  73.  (*-------------------------------------------------------------------------
  74.   | <mant> und <exp> werden zu einer REAL-Zahl <value> zusammengesetzt, die |
  75.   | als Funktionswert geliefert wird; es gilt:                              |
  76.   |                                                                         |
  77.   |          value = mant * 2^exp                                           |
  78.   |                                                                         |
  79.   | Da <mant> nicht notwendigerweise zwischen 1.0 und 2.0 liegen muss, son- |
  80.   | dern eine beliebige REAL-Zahl sein kann, lassen sich die beiden Funkti- |
  81.   | onen dazu verwenden, REAL-Zahlen sehr schnell mit Zweierpotenzen zu     |
  82.   | multiplizieren ( exp > 0 ) oder auch zu dividieren ( exp < 0 )!         |
  83.   | Die Multiplikation mit REAL-Zahlen ist z.B. ~100% schneller. Die Divi-  |
  84.   | sion sogar ~160%.                                                       |
  85.   |                                                                         |
  86.   | Es gilt:       x := SplitReal( value, exp );                            |
  87.   |                value = MakeReal( x, exp );                              |
  88.   |                                                                         |
  89.   | Ist <mant> = 0.0, wird auch 0.0 zurueckgeliefert.                       |
  90.   | Kommt es zum Ueberlauf, wird MAX(REAL) zurueckgeliefert.                |
  91.    -------------------------------------------------------------------------*)
  92.  
  93.  
  94.   PROCEDURE GetFraction     ((* EIN/ -- *)     value : REAL;
  95.   (* = MathCom.modf *)       (* -- /AUS *) VAR int   : INTEGER ): REAL;
  96.  
  97.   PROCEDURE GetLongFraction ((* EIN/ -- *)     value : LONGREAL;
  98.                              (* -- /AUS *) VAR int   : INTEGER  ): LONGREAL;
  99.  
  100.  (*-------------------------------------------------------------------------
  101.   | Spalten <value> in den ganzzahligen Anteil <int> samt Vorzeichen und den|
  102.   | stets positiven gebrochenen Anteil <frac> auf, der als Funktionswert    |
  103.   | geliefert wird.                                                         |
  104.   |                                                                         |
  105.   |               |value| = |int| + frac                                    |
  106.   |                                                                         |
  107.   | Es ist darauf zu achten, dass der Wertebereich fuer <int> nicht ueber-  |
  108.   | schritten wird, sonst gibt es falsche Ergebnisse oder Laufzeitfehler.   |
  109.    -------------------------------------------------------------------------*)
  110.  
  111.  
  112.   PROCEDURE SIGN    ((* EIN/ -- *) zahl : REAL ): INTEGER;
  113.  
  114.   PROCEDURE SIGND   ((* EIN/ -- *) zahl : LONGREAL ): INTEGER;
  115.  
  116.   PROCEDURE INTSIGN ((* EIN/ -- *) zahl : LONGINT ): INTEGER;
  117.  
  118.  (*-------------------------------------------------------------------------
  119.   | Signumsfunktion, INTSIGN ist auch fuer INTEGER-Zahlen geeignet.         |
  120.   |                                                                         |
  121.   |             / -1 , x < 0                                                |
  122.   |   SIGN(x) = |  0 , x = 0                                                |
  123.   |             \  1 , x > 0                                                |
  124.    -------------------------------------------------------------------------*)
  125.  
  126.  
  127.   PROCEDURE  real ((* EIN/ -- *) int : INTEGER ): REAL;
  128.  
  129.   PROCEDURE  Real ((* EIN/ -- *) lint : LONGINT ): LONGREAL;
  130.  
  131.  (*-------------------------------------------------------------------------
  132.   | Wandeln die uebergebende ganze Zahl in eine reelle Zahl; es kann nicht  |
  133.   | zu einem Ueberlauf kommen.                                              |
  134.    -------------------------------------------------------------------------*)
  135.  
  136.  
  137.   PROCEDURE  entier ((* EIN/ -- *) real : REAL ): INTEGER;
  138.  
  139.   PROCEDURE  Entier ((* EIN/ -- *) lreal : LONGREAL ): LONGINT;
  140.  
  141.  (*-------------------------------------------------------------------------
  142.   | Wandeln die uebergebene reelle Zahl in die groesste ganze Zahl, die     |
  143.   | kleiner oder gleich der reellen Zahl ist, somit besteht bei negativen   |
  144.   | Zahlen zwischen TRUNC und "entier" ein Unterschied:                     |
  145.   |                                                                         |
  146.   |    TRUNC( -1.0 ) = entier( -1.0 ) = -1, aber                            |
  147.   |    TRUNC( -1.1 ) = -1, entier( -1.1 ) = -2                              |
  148.   |                                                                         |
  149.   | Ueberschreitet die reelle Zahl den Wertebereich fuer die ganze Zahl,    |
  150.   | wird die jeweils kleinste bzw. groesste darstellbare ganze Zahl zurueck-|
  151.   | geliefert.                                                              |
  152.   | MINint und MINlongint werden korrekt gewandelt.                         |
  153.    -------------------------------------------------------------------------*)
  154.  
  155.  
  156.   PROCEDURE  round ((* EIN/ -- *) real : REAL ): INTEGER;
  157.  
  158.   PROCEDURE  Round ((* EIN/ -- *) lreal : LONGREAL ): LONGINT;
  159.  
  160.  (*-------------------------------------------------------------------------
  161.   | Liefern  TRUNC( x + 0.5 ) fuer positives  x, bzw.  TRUNC( x - 0.5 ) fuer|
  162.   | negatives  x. Bei einem Ueberlauf wird die jeweils kleinste bzw.        |
  163.   | groesste ganze Zahl zurueckgeliefert.                                   |
  164.    -------------------------------------------------------------------------*)
  165.  
  166. END  MathBase.
  167.